home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / pascal / oop55.zip / ODEMO.PAS < prev    next >
Pascal/Delphi Source File  |  1989-05-02  |  3KB  |  161 lines
  1.  
  2. { Turbo Streams }
  3. { Copyright (c) 1989 by Borland International, Inc. }
  4.  
  5. program ODemo;
  6. { Turbo Pascal 5.5 object-oriented example.
  7.   Demonstrates use of the OBJECTS unit's Stream, List and Node
  8.   object types. See OOPDEMOS.DOC for an overview of this program.
  9. }
  10.  
  11. uses Objects;
  12.  
  13. type
  14.  
  15.   TestNodePtr = ^TestNode;
  16.   TestNode = object(Node)
  17.     procedure Dump; virtual;
  18.   end;
  19.  
  20.   IntNodePtr = ^IntNode;
  21.   IntNode = object(TestNode)
  22.     Value: Longint;
  23.     constructor Init(V: Longint);
  24.     constructor Load(var S: Stream);
  25.     procedure Dump; virtual;
  26.     procedure Store(var S: Stream);
  27.   end;
  28.  
  29.   StringPtr = ^String;
  30.  
  31.   StrNodePtr = ^StrNode;
  32.   StrNode = object(TestNode)
  33.     Value: StringPtr;
  34.     constructor Init(V: String);
  35.     destructor Done; virtual;
  36.     constructor Load(var S: Stream);
  37.     procedure Dump; virtual;
  38.     procedure Store(var S: Stream);
  39.   end;
  40.  
  41.   TestList = object(List)
  42.     procedure Dump;
  43.   end;
  44.  
  45.   TestStream = object(BufStream)
  46.     procedure RegisterTypes; virtual;
  47.   end;
  48.  
  49. var
  50.   S: TestStream;
  51.   L: TestList;
  52.  
  53. procedure TestNode.Dump;
  54. begin
  55.   Abstract;
  56. end;
  57.  
  58. constructor IntNode.Init(V: Longint);
  59. begin
  60.   Value := V;
  61. end;
  62.  
  63. constructor IntNode.Load(var S: Stream);
  64. begin
  65.   S.Read(Value, SizeOf(Longint));
  66.   if S.Status <> 0 then Fail;
  67. end;
  68.  
  69. procedure IntNode.Dump;
  70. begin
  71.   WriteLn('Int: ', Value);
  72. end;
  73.  
  74. procedure IntNode.Store(var S: Stream);
  75. begin
  76.   S.Write(Value, SizeOf(Longint));
  77. end;
  78.  
  79. constructor StrNode.Init(V: String);
  80. begin
  81.   GetMem(Value, Length(V) + 1);
  82.   Value^ := V;
  83. end;
  84.  
  85. destructor StrNode.Done;
  86. begin
  87.   FreeMem(Value, Length(Value^) + 1);
  88. end;
  89.  
  90. constructor StrNode.Load(var S: Stream);
  91. var
  92.   L: Byte;
  93. begin
  94.   S.Read(L, 1);
  95.   GetMem(Value, L + 1);
  96.   Value^[0] := Chr(L);
  97.   S.Read(Value^[1], L);
  98.   if S.Status <> 0 then Fail;
  99. end;
  100.  
  101. procedure StrNode.Dump;
  102. begin
  103.   WriteLn('Str: ', Value^);
  104. end;
  105.  
  106. procedure StrNode.Store(var S: Stream);
  107. begin
  108.   S.Write(Value^, Length(Value^) + 1);
  109. end;
  110.  
  111. procedure TestList.Dump;
  112. var
  113.   P: TestNodePtr;
  114. begin
  115.   P := TestNodePtr(First);
  116.   while P <> nil do
  117.   begin
  118.     P^.Dump;
  119.     P := TestNodePtr(Next(P));
  120.   end;
  121. end;
  122.  
  123. procedure TestStream.RegisterTypes;
  124. begin
  125.   DosStream.RegisterTypes;
  126.   Register(TypeOf(IntNode), @IntNode.Store, @IntNode.Load);
  127.   Register(TypeOf(StrNode), @StrNode.Store, @StrNode.Load);
  128. end;
  129.  
  130. begin
  131.   WriteLn('Creating list.');
  132.   L.Clear;
  133.   L.Append(New(IntNodePtr, Init(1)));
  134.   L.Append(New(IntNodePtr, Init(10)));
  135.   L.Append(New(IntNodePtr, Init(100)));
  136.   L.Append(New(IntNodePtr, Init(1000)));
  137.   L.Append(New(StrNodePtr, Init('Hello world')));
  138.   L.Append(New(StrNodePtr, Init('Turbo Pascal version 5.5')));
  139.   L.Append(New(IntNodePtr, Init(-1)));
  140.   L.Append(New(IntNodePtr, Init(-2)));
  141.  
  142.   WriteLn('List to be saved:');
  143.   L.Dump;
  144.  
  145.   WriteLn('Saving list in TEST.DTA.');
  146.   S.Init('TEST.DTA', SCreate, 1024);
  147.   L.Store(S);
  148.   S.Done;
  149.  
  150.   WriteLn('Deleting list.');
  151.   L.Delete;
  152.  
  153.   WriteLn('Loading list from TEST.DTA.');
  154.   S.Init('TEST.DTA', SOpen, 1024);
  155.   L.Load(S);
  156.   S.Done;
  157.  
  158.   WriteLn('List that was loaded:');
  159.   L.Dump;
  160. end.
  161.